#[cfg(feature = "read")]

use alloc::boxed::Box;

use core::cmp::{Ord, Ordering};

use core::fmt::{self, Debug};

use core::iter::FromIterator;

use core::mem;

use core::num::Wrapping;

use super::util::{ArrayLike, ArrayVec};

use crate::common::{

    DebugFrameOffset, EhFrameOffset, Encoding, Format, Register, SectionId, Vendor,

};

use crate::constants::{self, DwEhPe};

use crate::endianity::Endianity;

use crate::read::{

    EndianSlice, Error, Expression, Reader, ReaderOffset, Result, Section, StoreOnHeap,

};

/// `DebugFrame` contains the `.debug_frame` section's frame unwinding

/// information required to unwind to and recover registers from older frames on

/// the stack. For example, this is useful for a debugger that wants to print

/// locals in a backtrace.

///

/// Most interesting methods are defined in the

/// [`UnwindSection`](trait.UnwindSection.html) trait.

///

/// ### Differences between `.debug_frame` and `.eh_frame`

///

/// While the `.debug_frame` section's information has a lot of overlap with the

/// `.eh_frame` section's information, the `.eh_frame` information tends to only

/// encode the subset of information needed for exception handling. Often, only

/// one of `.eh_frame` or `.debug_frame` will be present in an object file.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub struct DebugFrame<R: Reader> {

    section: R,

    address_size: u8,

    segment_size: u8,

    vendor: Vendor,

}

impl<R: Reader> DebugFrame<R> {

    /// Set the size of a target address in bytes.

    ///

    /// This defaults to the native word size.

    /// This is only used if the CIE version is less than 4.

    /// Set the size of a segment selector in bytes.

    ///

    /// This defaults to 0.

    /// This is only used if the CIE version is less than 4.

    /// Set the vendor extensions to use.

    ///

    /// This defaults to `Vendor::Default`.

}

impl<'input, Endian> DebugFrame<EndianSlice<'input, Endian>>

where

    Endian: Endianity,

{

    /// Construct a new `DebugFrame` instance from the data in the

    /// `.debug_frame` section.

    ///

    /// It is the caller's responsibility to read the section and present it as

    /// a `&[u8]` slice. That means using some ELF loader on Linux, a Mach-O

    /// loader on macOS, etc.

    ///

    /// ```

    /// use gimli::{DebugFrame, NativeEndian};

    ///

    /// // Use with `.debug_frame`

    /// # let buf = [0x00, 0x01, 0x02, 0x03];

    /// # let read_debug_frame_section_somehow = || &buf;

    /// let debug_frame = DebugFrame::new(read_debug_frame_section_somehow(), NativeEndian);

    /// ```

}

impl<R: Reader> Section<R> for DebugFrame<R> {

}

impl<R: Reader> From<R> for DebugFrame<R> {

}

/// `EhFrameHdr` contains the information about the `.eh_frame_hdr` section.

///

/// A pointer to the start of the `.eh_frame` data, and optionally, a binary

/// search table of pointers to the `.eh_frame` records that are found in this section.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub struct EhFrameHdr<R: Reader>(R);

/// `ParsedEhFrameHdr` contains the parsed information from the `.eh_frame_hdr` section.

#[derive(Clone, Debug)]

pub struct ParsedEhFrameHdr<R: Reader> {

    address_size: u8,

    section: R,

    eh_frame_ptr: Pointer,

    fde_count: u64,

    table_enc: DwEhPe,

    table: R,

}

impl<'input, Endian> EhFrameHdr<EndianSlice<'input, Endian>>

where

    Endian: Endianity,

{

    /// Constructs a new `EhFrameHdr` instance from the data in the `.eh_frame_hdr` section.

}

impl<R: Reader> EhFrameHdr<R> {

    /// Parses this `EhFrameHdr` to a `ParsedEhFrameHdr`.

        let fde_count;

        } else {

        }

}

impl<R: Reader> Section<R> for EhFrameHdr<R> {

}

impl<R: Reader> From<R> for EhFrameHdr<R> {

}

impl<R: Reader> ParsedEhFrameHdr<R> {

    /// Returns the address of the binary's `.eh_frame` section.

    /// Retrieves the CFI binary search table, if there is one.

        } else {

        }

}

/// An iterator for `.eh_frame_hdr` section's binary search table.

///

/// Each table entry consists of a tuple containing an  `initial_location` and `address`.

/// The `initial location` represents the first address that the targeted FDE

/// is able to decode. The `address` is the address of the FDE in the `.eh_frame` section.

/// The `address` can be converted with `EhHdrTable::pointer_to_offset` and `EhFrame::fde_from_offset` to an FDE.

#[derive(Debug)]

pub struct EhHdrTableIter<'a, 'bases, R: Reader> {

    hdr: &'a ParsedEhFrameHdr<R>,

    table: R,

    bases: &'bases BaseAddresses,

    remain: u64,

}

impl<'a, 'bases, R: Reader> EhHdrTableIter<'a, 'bases, R> {

    /// Yield the next entry in the `EhHdrTableIter`.

    /// Yield the nth entry in the `EhHdrTableIter`

        use core::convert::TryFrom;

            constants::DW_EH_PE_uleb128 | constants::DW_EH_PE_sleb128 => {

            }

        };

}

#[cfg(feature = "fallible-iterator")]

impl<'a, 'bases, R: Reader> fallible_iterator::FallibleIterator for EhHdrTableIter<'a, 'bases, R> {

    type Item = (Pointer, Pointer);

    type Error = Error;

    fn next(&mut self) -> Result<Option<Self::Item>> {

        EhHdrTableIter::next(self)

    }

    fn size_hint(&self) -> (usize, Option<usize>) {

        use core::convert::TryInto;

        (

            self.remain.try_into().unwrap_or(0),

            self.remain.try_into().ok(),

        )

    }

    fn nth(&mut self, n: usize) -> Result<Option<Self::Item>> {

        EhHdrTableIter::nth(self, n)

    }

}

/// The CFI binary search table that is an optional part of the `.eh_frame_hdr` section.

#[derive(Debug, Clone)]

pub struct EhHdrTable<'a, R: Reader> {

    hdr: &'a ParsedEhFrameHdr<R>,

}

impl<'a, R: Reader + 'a> EhHdrTable<'a, R> {

    /// Return an iterator that can walk the `.eh_frame_hdr` table.

    ///

    /// Each table entry consists of a tuple containing an `initial_location` and `address`.

    /// The `initial location` represents the first address that the targeted FDE

    /// is able to decode. The `address` is the address of the FDE in the `.eh_frame` section.

    /// The `address` can be converted with `EhHdrTable::pointer_to_offset` and `EhFrame::fde_from_offset` to an FDE.

    /// *Probably* returns a pointer to the FDE for the given address.

    ///

    /// This performs a binary search, so if there is no FDE for the given address,

    /// this function **will** return a pointer to any other FDE that's close by.

    ///

    /// To be sure, you **must** call `contains` on the FDE.

            constants::DW_EH_PE_uleb128 | constants::DW_EH_PE_sleb128 => {

            }

        };

                Ordering::Equal => {

                }

            }

        }

    /// Convert a `Pointer` to a section offset.

    ///

    /// This does not support indirect pointers.

        // Calculate the offset in the EhFrame section

    /// Returns a parsed FDE for the given address, or `NoUnwindInfoForAddress`

    /// if there are none.

    ///

    /// You must provide a function to get its associated CIE. See

    /// `PartialFrameDescriptionEntry::parse` for more information.

    ///

    /// # Example

    ///

    /// ```

    /// # use gimli::{BaseAddresses, EhFrame, ParsedEhFrameHdr, EndianSlice, NativeEndian, Error, UnwindSection};

    /// # fn foo() -> Result<(), Error> {

    /// # let eh_frame: EhFrame<EndianSlice<NativeEndian>> = unreachable!();

    /// # let eh_frame_hdr: ParsedEhFrameHdr<EndianSlice<NativeEndian>> = unimplemented!();

    /// # let addr = 0;

    /// # let bases = unimplemented!();

    /// let table = eh_frame_hdr.table().unwrap();

    /// let fde = table.fde_for_address(&eh_frame, &bases, addr, EhFrame::cie_from_offset)?;

    /// # Ok(())

    /// # }

    /// ```

        } else {

        }

    #[inline]

    #[doc(hidden)]

    #[deprecated(note = "Method renamed to fde_for_address; use that instead.")]

    /// Returns the frame unwind information for the given address,

    /// or `NoUnwindInfoForAddress` if there are none.

    ///

    /// You must provide a function to get the associated CIE. See

    /// `PartialFrameDescriptionEntry::parse` for more information.

}

/// `EhFrame` contains the frame unwinding information needed during exception

/// handling found in the `.eh_frame` section.

///

/// Most interesting methods are defined in the

/// [`UnwindSection`](trait.UnwindSection.html) trait.

///

/// See

/// [`DebugFrame`](./struct.DebugFrame.html#differences-between-debug_frame-and-eh_frame)

/// for some discussion on the differences between `.debug_frame` and

/// `.eh_frame`.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub struct EhFrame<R: Reader> {

    section: R,

    address_size: u8,

    vendor: Vendor,

}

impl<R: Reader> EhFrame<R> {

    /// Set the size of a target address in bytes.

    ///

    /// This defaults to the native word size.

    /// Set the vendor extensions to use.

    ///

    /// This defaults to `Vendor::Default`.

}

impl<'input, Endian> EhFrame<EndianSlice<'input, Endian>>

where

    Endian: Endianity,

{

    /// Construct a new `EhFrame` instance from the data in the

    /// `.eh_frame` section.

    ///

    /// It is the caller's responsibility to read the section and present it as

    /// a `&[u8]` slice. That means using some ELF loader on Linux, a Mach-O

    /// loader on macOS, etc.

    ///

    /// ```

    /// use gimli::{EhFrame, EndianSlice, NativeEndian};

    ///

    /// // Use with `.eh_frame`

    /// # let buf = [0x00, 0x01, 0x02, 0x03];

    /// # let read_eh_frame_section_somehow = || &buf;

    /// let eh_frame = EhFrame::new(read_eh_frame_section_somehow(), NativeEndian);

    /// ```

}

impl<R: Reader> Section<R> for EhFrame<R> {

}

impl<R: Reader> From<R> for EhFrame<R> {

}

// This has to be `pub` to silence a warning (that is deny(..)'d by default) in

// rustc. Eventually, not having this `pub` will become a hard error.

#[doc(hidden)]

#[allow(missing_docs)]

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum CieOffsetEncoding {

    U32,

    U64,

}

/// An offset into an `UnwindSection`.

//

// Needed to avoid conflicting implementations of `Into<T>`.

pub trait UnwindOffset<T = usize>: Copy + Debug + Eq + From<T>

where

    T: ReaderOffset,

{

    /// Convert an `UnwindOffset<T>` into a `T`.

    fn into(self) -> T;

}

impl<T> UnwindOffset<T> for DebugFrameOffset<T>

where

    T: ReaderOffset,

{

    #[inline]

}

impl<T> UnwindOffset<T> for EhFrameOffset<T>

where

    T: ReaderOffset,

{

    #[inline]

}

/// This trait completely encapsulates everything that is different between

/// `.eh_frame` and `.debug_frame`, as well as all the bits that can change

/// between DWARF versions.

#[doc(hidden)]

pub trait _UnwindSectionPrivate<R: Reader> {

    /// Get the underlying section data.

    fn section(&self) -> &R;

    /// Returns true if the given length value should be considered an

    /// end-of-entries sentinel.

    fn length_value_is_end_of_entries(length: R::Offset) -> bool;

    /// Return true if the given offset if the CIE sentinel, false otherwise.

    fn is_cie(format: Format, id: u64) -> bool;

    /// Return the CIE offset/ID encoding used by this unwind section with the

    /// given DWARF format.

    fn cie_offset_encoding(format: Format) -> CieOffsetEncoding;

    /// For `.eh_frame`, CIE offsets are relative to the current position. For

    /// `.debug_frame`, they are relative to the start of the section. We always

    /// internally store them relative to the section, so we handle translating

    /// `.eh_frame`'s relative offsets in this method. If the offset calculation

    /// underflows, return `None`.

    fn resolve_cie_offset(&self, base: R::Offset, offset: R::Offset) -> Option<R::Offset>;

    /// Does this version of this unwind section encode address and segment

    /// sizes in its CIEs?

    fn has_address_and_segment_sizes(version: u8) -> bool;

    /// The address size to use if `has_address_and_segment_sizes` returns false.

    fn address_size(&self) -> u8;

    /// The segment size to use if `has_address_and_segment_sizes` returns false.

    fn segment_size(&self) -> u8;

    /// The vendor extensions to use.

    fn vendor(&self) -> Vendor;

}

/// A section holding unwind information: either `.debug_frame` or

/// `.eh_frame`. See [`DebugFrame`](./struct.DebugFrame.html) and

/// [`EhFrame`](./struct.EhFrame.html) respectively.

pub trait UnwindSection<R: Reader>: Clone + Debug + _UnwindSectionPrivate<R> {

    /// The offset type associated with this CFI section. Either

    /// `DebugFrameOffset` or `EhFrameOffset`.

    type Offset: UnwindOffset<R::Offset>;

    /// Iterate over the `CommonInformationEntry`s and `FrameDescriptionEntry`s

    /// in this `.debug_frame` section.

    ///

    /// Can be [used with

    /// `FallibleIterator`](./index.html#using-with-fallibleiterator).

    /// Parse the `CommonInformationEntry` at the given offset.

    /// Parse the `PartialFrameDescriptionEntry` at the given offset.

    /// Parse the `FrameDescriptionEntry` at the given offset.

    /// Find the `FrameDescriptionEntry` for the given address.

    ///

    /// If found, the FDE is returned.  If not found,

    /// `Err(gimli::Error::NoUnwindInfoForAddress)` is returned.

    /// If parsing fails, the error is returned.

    ///

    /// You must provide a function to get its associated CIE. See

    /// `PartialFrameDescriptionEntry::parse` for more information.

    ///

    /// Note: this iterates over all FDEs. If available, it is possible

    /// to do a binary search with `EhFrameHdr::fde_for_address` instead.

                }

            }

        }

    /// Find the frame unwind information for the given address.

    ///

    /// If found, the unwind information is returned.  If not found,

    /// `Err(gimli::Error::NoUnwindInfoForAddress)` is returned. If parsing or

    /// CFI evaluation fails, the error is returned.

    ///

    /// ```

    /// use gimli::{BaseAddresses, EhFrame, EndianSlice, NativeEndian, UnwindContext,

    ///             UnwindSection};

    ///

    /// # fn foo() -> gimli::Result<()> {

    /// # let read_eh_frame_section = || unimplemented!();

    /// // Get the `.eh_frame` section from the object file. Alternatively,

    /// // use `EhFrame` with the `.eh_frame` section of the object file.

    /// let eh_frame = EhFrame::new(read_eh_frame_section(), NativeEndian);

    ///

    /// # let get_frame_pc = || unimplemented!();

    /// // Get the address of the PC for a frame you'd like to unwind.

    /// let address = get_frame_pc();

    ///

    /// // This context is reusable, which cuts down on heap allocations.

    /// let ctx = UnwindContext::new();

    ///

    /// // Optionally provide base addresses for any relative pointers. If a

    /// // base address isn't provided and a pointer is found that is relative to

    /// // it, we will return an `Err`.

    /// # let address_of_text_section_in_memory = unimplemented!();

    /// # let address_of_got_section_in_memory = unimplemented!();

    /// let bases = BaseAddresses::default()

    ///     .set_text(address_of_text_section_in_memory)

    ///     .set_got(address_of_got_section_in_memory);

    ///

    /// let unwind_info = eh_frame.unwind_info_for_address(

    ///     &bases,

    ///     &mut ctx,

    ///     address,

    ///     EhFrame::cie_from_offset,

    /// )?;

    ///

    /// # let do_stuff_with = |_| unimplemented!();

    /// do_stuff_with(unwind_info);

    /// # let _ = ctx;

    /// # unreachable!()

    /// # }

    /// ```

    #[inline]

}

impl<R: Reader> _UnwindSectionPrivate<R> for DebugFrame<R> {

        }

        }

}

impl<R: Reader> UnwindSection<R> for DebugFrame<R> {

    type Offset = DebugFrameOffset<R::Offset>;

}

impl<R: Reader> _UnwindSectionPrivate<R> for EhFrame<R> {

}

impl<R: Reader> UnwindSection<R> for EhFrame<R> {

    type Offset = EhFrameOffset<R::Offset>;

}

/// Optional base addresses for the relative `DW_EH_PE_*` encoded pointers.

///

/// During CIE/FDE parsing, if a relative pointer is encountered for a base

/// address that is unknown, an Err will be returned.

///

/// ```

/// use gimli::BaseAddresses;

///

/// # fn foo() {

/// # let address_of_eh_frame_hdr_section_in_memory = unimplemented!();

/// # let address_of_eh_frame_section_in_memory = unimplemented!();

/// # let address_of_text_section_in_memory = unimplemented!();

/// # let address_of_got_section_in_memory = unimplemented!();

/// # let address_of_the_start_of_current_func = unimplemented!();

/// let bases = BaseAddresses::default()

///     .set_eh_frame_hdr(address_of_eh_frame_hdr_section_in_memory)

///     .set_eh_frame(address_of_eh_frame_section_in_memory)

///     .set_text(address_of_text_section_in_memory)

///     .set_got(address_of_got_section_in_memory);

/// # let _ = bases;

/// # }

/// ```

#[derive(Clone, Default, Debug, PartialEq, Eq)]

pub struct BaseAddresses {

    /// The base addresses to use for pointers in the `.eh_frame_hdr` section.

    pub eh_frame_hdr: SectionBaseAddresses,

    /// The base addresses to use for pointers in the `.eh_frame` section.

    pub eh_frame: SectionBaseAddresses,

}

/// Optional base addresses for the relative `DW_EH_PE_*` encoded pointers

/// in a particular section.

///

/// See `BaseAddresses` for methods that are helpful in setting these addresses.

#[derive(Clone, Default, Debug, PartialEq, Eq)]

pub struct SectionBaseAddresses {

    /// The address of the section containing the pointer.

    pub section: Option<u64>,

    /// The base address for text relative pointers.

    /// This is generally the address of the `.text` section.

    pub text: Option<u64>,

    /// The base address for data relative pointers.

    ///

    /// For pointers in the `.eh_frame_hdr` section, this is the address

    /// of the `.eh_frame_hdr` section

    ///

    /// For pointers in the `.eh_frame` section, this is generally the

    /// global pointer, such as the address of the `.got` section.

    pub data: Option<u64>,

}

impl BaseAddresses {

    /// Set the `.eh_frame_hdr` section base address.

    #[inline]

    /// Set the `.eh_frame` section base address.

    #[inline]

    /// Set the `.text` section base address.

    #[inline]

    /// Set the `.got` section base address.

    #[inline]

}

/// An iterator over CIE and FDE entries in a `.debug_frame` or `.eh_frame`

/// section.

///

/// Some pointers may be encoded relative to various base addresses. Use the

/// [`BaseAddresses`](./struct.BaseAddresses.html) parameter to provide them. By

/// default, none are provided. If a relative pointer is encountered for a base

/// address that is unknown, an `Err` will be returned and iteration will abort.

///

/// Can be [used with

/// `FallibleIterator`](./index.html#using-with-fallibleiterator).

///

/// ```

/// use gimli::{BaseAddresses, EhFrame, EndianSlice, NativeEndian, UnwindSection};

///

/// # fn foo() -> gimli::Result<()> {

/// # let read_eh_frame_somehow = || unimplemented!();

/// let eh_frame = EhFrame::new(read_eh_frame_somehow(), NativeEndian);

///

/// # let address_of_eh_frame_hdr_section_in_memory = unimplemented!();

/// # let address_of_eh_frame_section_in_memory = unimplemented!();

/// # let address_of_text_section_in_memory = unimplemented!();

/// # let address_of_got_section_in_memory = unimplemented!();

/// # let address_of_the_start_of_current_func = unimplemented!();

/// // Provide base addresses for relative pointers.

/// let bases = BaseAddresses::default()

///     .set_eh_frame_hdr(address_of_eh_frame_hdr_section_in_memory)

///     .set_eh_frame(address_of_eh_frame_section_in_memory)

///     .set_text(address_of_text_section_in_memory)

///     .set_got(address_of_got_section_in_memory);

///

/// let mut entries = eh_frame.entries(&bases);

///

/// # let do_stuff_with = |_| unimplemented!();

/// while let Some(entry) = entries.next()? {

///     do_stuff_with(entry)

/// }

/// # unreachable!()

/// # }

/// ```

#[derive(Clone, Debug)]

pub struct CfiEntriesIter<'bases, Section, R>

where

    R: Reader,

    Section: UnwindSection<R>,

{

    section: Section,

    bases: &'bases BaseAddresses,

    input: R,

}

impl<'bases, Section, R> CfiEntriesIter<'bases, Section, R>

where

    R: Reader,

    Section: UnwindSection<R>,

{

    /// Advance the iterator to the next entry.

            }

            Ok(None) => {

            }

        }

}

#[cfg(feature = "fallible-iterator")]

impl<'bases, Section, R> fallible_iterator::FallibleIterator for CfiEntriesIter<'bases, Section, R>

where

    R: Reader,

    Section: UnwindSection<R>,

{

    type Item = CieOrFde<'bases, Section, R>;

    type Error = Error;

    fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {

        CfiEntriesIter::next(self)

    }

}

/// Either a `CommonInformationEntry` (CIE) or a `FrameDescriptionEntry` (FDE).

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum CieOrFde<'bases, Section, R>

where

    R: Reader,

    Section: UnwindSection<R>,

{

    /// This CFI entry is a `CommonInformationEntry`.

    Cie(CommonInformationEntry<R>),

    /// This CFI entry is a `FrameDescriptionEntry`, however fully parsing it

    /// requires parsing its CIE first, so it is left in a partially parsed

    /// state.

    Fde(PartialFrameDescriptionEntry<'bases, Section, R>),

}

    };

    };

    } else {

    }

/// We support the z-style augmentation [defined by `.eh_frame`][ehframe].

///

/// [ehframe]: https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html

#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]

pub struct Augmentation {

    /// > A 'L' may be present at any position after the first character of the

    /// > string. This character may only be present if 'z' is the first character

    /// > of the string. If present, it indicates the presence of one argument in

    /// > the Augmentation Data of the CIE, and a corresponding argument in the

    /// > Augmentation Data of the FDE. The argument in the Augmentation Data of

    /// > the CIE is 1-byte and represents the pointer encoding used for the

    /// > argument in the Augmentation Data of the FDE, which is the address of a

    /// > language-specific data area (LSDA). The size of the LSDA pointer is

    /// > specified by the pointer encoding used.

    lsda: Option<constants::DwEhPe>,

    /// > A 'P' may be present at any position after the first character of the

    /// > string. This character may only be present if 'z' is the first character

    /// > of the string. If present, it indicates the presence of two arguments in

    /// > the Augmentation Data of the CIE. The first argument is 1-byte and

    /// > represents the pointer encoding used for the second argument, which is

    /// > the address of a personality routine handler. The size of the

    /// > personality routine pointer is specified by the pointer encoding used.

    personality: Option<(constants::DwEhPe, Pointer)>,

    /// > A 'R' may be present at any position after the first character of the

    /// > string. This character may only be present if 'z' is the first character

    /// > of the string. If present, The Augmentation Data shall include a 1 byte

    /// > argument that represents the pointer encoding for the address pointers

    /// > used in the FDE.

    fde_address_encoding: Option<constants::DwEhPe>,

    /// True if this CIE's FDEs are trampolines for signal handlers.

    is_signal_trampoline: bool,

}

impl Augmentation {

            "Augmentation::parse should only be called if we have an augmentation"

        );

                b'z' => {

                }

                b'L' => {

                }

                b'P' => {

                }

                b'R' => {

                }

            }

        }

}

/// Parsed augmentation data for a `FrameDescriptEntry`.

#[derive(Clone, Debug, Default, PartialEq, Eq)]

struct AugmentationData {

    lsda: Option<Pointer>,

}

impl AugmentationData {

        // In theory, we should be iterating over the original augmentation

        // string, interpreting each character, and reading the appropriate bits

        // out of the augmentation data as we go. However, the only character

        // that defines augmentation data in the FDE is the 'L' character, so we

        // can just check for its presence directly.

}

/// > A Common Information Entry holds information that is shared among many

/// > Frame Description Entries. There is at least one CIE in every non-empty

/// > `.debug_frame` section.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct CommonInformationEntry<R, Offset = <R as Reader>::Offset>

where

    R: Reader<Offset = Offset>,

    Offset: ReaderOffset,

{

    /// The offset of this entry from the start of its containing section.

    offset: Offset,

    /// > A constant that gives the number of bytes of the CIE structure, not

    /// > including the length field itself (see Section 7.2.2). The size of the

    /// > length field plus the value of length must be an integral multiple of

    /// > the address size.

    length: Offset,

    format: Format,

    /// > A version number (see Section 7.23). This number is specific to the

    /// > call frame information and is independent of the DWARF version number.

    version: u8,

    /// The parsed augmentation, if any.

    augmentation: Option<Augmentation>,

    /// > The size of a target address in this CIE and any FDEs that use it, in

    /// > bytes. If a compilation unit exists for this frame, its address size

    /// > must match the address size here.

    address_size: u8,

    /// "The size of a segment selector in this CIE and any FDEs that use it, in

    /// bytes."

    segment_size: u8,

    /// "A constant that is factored out of all advance location instructions

    /// (see Section 6.4.2.1)."

    code_alignment_factor: u64,

    /// > A constant that is factored out of certain offset instructions (see

    /// > below). The resulting value is (operand * data_alignment_factor).

    data_alignment_factor: i64,

    /// > An unsigned LEB128 constant that indicates which column in the rule

    /// > table represents the return address of the function. Note that this

    /// > column might not correspond to an actual machine register.

    return_address_register: Register,

    /// > A sequence of rules that are interpreted to create the initial setting

    /// > of each column in the table.

    ///

    /// > The default rule for all columns before interpretation of the initial

    /// > instructions is the undefined rule. However, an ABI authoring body or a

    /// > compilation system authoring body may specify an alternate default

    /// > value for any or all columns.

    ///

    /// This is followed by `DW_CFA_nop` padding until the end of `length` bytes

    /// in the input.

    initial_instructions: R,

}

impl<R: Reader> CommonInformationEntry<R> {